home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 4 / FM Towns Free Software Collection 4 - Disc 1.iso / t_os / asm09 / asm09.c next >
Text File  |  1991-10-18  |  53KB  |  1,297 lines
  1. /***************************************************************************/
  2. /*                                                                         */
  3. /*　　　　６８０９＆６３０９アセンブラ　ＡＳＭ０９  Version1.0             */
  4. /*                                      １９９１年８月２３日（水）         */
  5. /*                                     Ｂｙ　Ｊｕｎ．Ｄｉｍｅ              */
  6. /*                                                                         */
  7. /*        このアセンブラはＦＭ－Ｔｏｗｎｓを対象にかかれたものであり、     */
  8. /*　　　Ｈｉｇｈ－Ｃ以外及びＤＯＳ｜Ｅｘｔｅｎｄｅｒ以外での動作は確認     */
  9. /*　　　していません。                                                     */
  10. /***************************************************************************/
  11. pragma Ipath("a:/inc/");
  12.  
  13. #include <stdio.h>
  14. #include <string.h>
  15. #include <stdlib.h>
  16. #include <ctype.h>
  17.  
  18. #define BEGIN      {              /****************************************/
  19. #define END        }              /*                                      */
  20. #define IF         if(            /*    この表記法は純正Ｃプログラマには  */
  21. #define THEN       ){             /*  許し難いものでしょうが、Ｃの表記に  */
  22. #define ELSE       }else{         /*  にいつまでも馴れない者の悪掻きだと  */
  23. #define ELSEIF     }else{if(      /*  思ってやってください。ＰＡＳＣＡＬ  */
  24. #define ENDIF      }              /*  風に最初するつもりだったのですが、  */
  25. #define WHILE      while(         /*  長年親しんだＭＷ－Ｂａｓｉｃ風にな  */
  26. #define DO         ){             /*  ってしまいました。                  */
  27. #define FOR        for(           /*                                      */
  28. #define TO         ;              /*                                      */
  29. #define BY         ;              /*                                      */
  30. #define LOOP       for(;;){       /*                                      */
  31. #define ENDWHILE   }              /*                                      */
  32. #define REPEAT     do{            /*                                      */
  33. #define UNTIL(s)   }while(s);     /*                                      */
  34. #define SWITCH(s)  switch(s){     /*                                      */
  35. #define CASE(s)    case(s):       /*                                      */
  36. #define DEFAULT    default:       /*                                      */
  37. #define BREAK      break;         /*                                      */
  38. #define ENDSWITCH  }              /*                                      */
  39. #define RETURN(s)  return(s);     /*                                      */
  40. #define FUNCTION   int            /*                                      */
  41. #define MODULE     void           /*                                      */
  42. #define OR         ||             /*                                      */
  43. #define AND        &&             /*                                      */
  44. #define NOT        !              /*                                      */
  45. #define EQU        ==             /*                                      */
  46. #define NEQ        !=             /*                                      */
  47. #define MODULE     void           /*                                      */
  48. #define ON         0xFF           /*                                      */
  49. #define OFF        0x00           /*                                      */
  50. #define TAB        0x09           /*                                      */
  51. #define LF         0x0A           /*                                      */
  52. #define CR         0x0D           /*                                      */
  53. #define BLANK      0x20           /*                                      */
  54. #define COMMA      0x2C           /*                                      */
  55. #define ZERO       0x00           /****************************************/
  56.  
  57. typedef struct OP  {char op[5],Code ;} OPCODE;
  58. typedef struct SYM {char *SP,*SA    ;} SYMBOL;
  59. typedef struct CA  {char      *Label
  60.                        ,*Instruction
  61.                            ,*Argment;
  62.                     int     ArgmentC;} COMLINE;
  63. typedef struct CI  {char       *Code
  64.                            ,*Argment;
  65.                     int   Code_Count
  66.                           ,Arg_Count;} CODEINF;
  67.  
  68. struct Registar { char         R[3];
  69.                   int               Numb;
  70.                 } RNum[16] = {{ "D",0x06},{ "X",0x10},{ "Y",0x20},{ "U",0x40}
  71.                              ,{ "S",0x40},{"PC",0x80},{ "W",0x00},{ "V",0x00}
  72.                              ,{ "A",0x04},{ "B",0x02},{"CC",0x01},{"DP",0x08}
  73.                              ,{ "N",0x00},{ "M",0x00},{ "E",0x00},{ "F",0x00}};
  74. char Post_Register[4][2] = {"X","Y","U","S"};
  75. char Code_Info[2][3] = {{0x70,0x00,0x60},{0x30,0x00,0x20}};
  76. char PArea[65536]     ,Symbol_Table[65536]
  77.     ,EQUL_Table[65536],EQU_Table[65536]
  78.     ,SETL_Table[65536],SET_Table[65536];
  79. int Pass_flag = 0,Symbol_Count;
  80. SYMBOL Symbol[255],Equ[255],Set[255];
  81.  
  82.  
  83. int           Byte_Count  ;
  84.  
  85. /******************** 6309 asm Main routin **********************************/
  86. /*                                                                          */
  87. /*                                                                          */
  88. /*                                                                          */
  89. /*                                                                          */
  90. /*                                                                          */
  91. /*　　　                                                                    */
  92. /*                                                                          */
  93. /*                                                                          */
  94. /****************************************************************************/
  95. MODULE main(argc,argv)
  96. int         argc;
  97. char            *argv[];
  98. BEGIN
  99.   FILE *fp,*temp_fp,*Ofp;
  100.   char Label[255],Instruction[10],Argment[255],One_Line[255]/*,*TP*/;
  101. /*  SYMBOL Symbol[255],Equ[255],Set[255];*/
  102.   COMLINE ComLine;
  103. /*  CODEINF CodeInf;*/
  104.   int i,bc,ArgmentC,c,Line_Count,EQU_Count,SET_Count;
  105.   Byte_Count = bc = c = Line_Count = Symbol_Count = EQU_Count = SET_Count = 0;
  106.   ComLine.Label       = Label;
  107.   ComLine.Instruction = Instruction;
  108.   ComLine.Argment     = Argment;
  109.  
  110.   IF argc < 2 THEN
  111.     exit(0);
  112.   ENDIF
  113.  
  114.   i = 0;
  115.   WHILE strcmp((char *)argv[i],"-c") NEQ ZERO AND i < argc DO
  116.     i++;
  117.   ENDWHILE
  118.   fp = fopen(argv[i + 1],"r");
  119.   i = 0;
  120.   WHILE strcmp((char *)argv[i],"-o") NEQ ZERO AND i < argc DO
  121.     i++;
  122.   ENDWHILE
  123.   Ofp = fopen(argv[i + 1],"w");
  124.   temp_fp = fopen("temp.$$$","w");
  125.  
  126.   Symbol[Symbol_Count].SP = Symbol_Table;
  127.   Equ[EQU_Count].SP = EQUL_Table;
  128.   Set[SET_Count].SP = SETL_Table;
  129.   Equ[EQU_Count].SA = EQU_Table;
  130.   Set[SET_Count].SA = SET_Table;  
  131.   WHILE fgets(One_Line,255,fp) NEQ ZERO DO
  132.  /*   printf("%05d ",Line_Count++);*/
  133.     IF One_Line[0] EQU '*' THEN
  134.       strcpy(Label,One_Line);
  135.       Label[strlen(Label) - 1] = ZERO;
  136. /*      printf("     %s\n",Label);*/
  137.     ELSE
  138.       Command_Analysis(One_Line,Label,Instruction,Argment);
  139.       fputs(Label,temp_fp);fputs(" ",temp_fp);
  140.       fputs(Instruction,temp_fp);fputs(" ",temp_fp);
  141. /*      fputs(Argment,temp_fp);fputs(" \n",temp_fp);*/
  142.       IF   strcmp(Instruction,"SET") EQU ZERO
  143.         OR strcmp(Instruction,"EQU") EQU ZERO THEN
  144.         IF strcmp(Instruction,"EQU") EQU ZERO THEN
  145.           Symbol_Entry(ComLine,Equ,&EQU_Count);
  146.         ENDIF
  147.         IF strcmp(Instruction,"SET") EQU ZERO THEN
  148.          Symbol_Entry(ComLine,Set,&SET_Count);
  149.         ENDIF        
  150.       ELSE
  151.         IF Symbol_Entry(ComLine,Symbol,&Symbol_Count) > ZERO THEN
  152.           Symbol[Symbol_Count - 1].SA = (char *)bc;
  153.         ENDIF
  154.       ENDIF
  155.       IF Instruction[0] NEQ ZERO THEN
  156.         fputs(Argment,temp_fp);fputs(" \n",temp_fp);
  157.         ComLine.ArgmentC = ArgmentC = Argment_Count(Argment);
  158. /*        fputs(Argment,temp_fp);fputs(" \n",temp_fp);*/
  159. /*        Number_Analysis(Argment,ArgmentC,temp_fp);*/
  160.         IF ArgmentC EQU 1 THEN
  161.           
  162.         ENDIF
  163.         IF (c = One_Byte_Code(Instruction,&PArea[bc])) EQU 0 THEN
  164.           IF (c = Two_Byte_Code(Instruction,&PArea[bc])) EQU 0 THEN
  165.             IF (c = Search_Branch(Instruction
  166.                                        ,Argment,&PArea[bc],bc)) EQU 0 THEN
  167.                IF (c = Inherent_Code(Instruction,Argment
  168.                                        ,ArgmentC,&PArea[bc])) EQU 0 THEN
  169.                  IF (c = ExImmediate_Code(Instruction,Argment
  170.                                        ,ArgmentC,&PArea[bc])) EQU 0 THEN
  171.                    IF (c = InInstruction(Instruction,Argment
  172.                                        ,ArgmentC,&PArea[bc])) EQU 0 THEN
  173.  
  174.                    ENDIF
  175.                  ENDIF 
  176.               ENDIF 
  177.             ENDIF
  178.           ENDIF
  179.         ENDIF
  180.       ENDIF
  181.  
  182. /*      Command_Line_Print(ComLine,bc,c);*/
  183.       bc = bc + c;
  184.     ENDIF
  185.   ENDWHILE
  186.   fclose(fp);
  187.   fclose(temp_fp);
  188.  
  189.   Pass_flag = 1;
  190.   Line_Count = bc = 0;
  191.   fp = fopen("temp.$$$","r");
  192.   
  193.   WHILE fgets(One_Line,255,fp) NEQ ZERO DO
  194.     printf("%05d ",Line_Count++);
  195.     IF One_Line[0] EQU '*' THEN
  196.       printf("     %s\n",Label);
  197.     ELSE
  198.       Command_Analysis(One_Line,Label,Instruction,Argment);
  199.       IF Instruction[0] NEQ ZERO THEN
  200.         ComLine.ArgmentC = ArgmentC = Argment_Count(Argment);
  201.         IF (c = One_Byte_Code(Instruction,&PArea[bc])) EQU 0 THEN
  202.           IF (c = Two_Byte_Code(Instruction,&PArea[bc])) EQU 0 THEN
  203.             IF (c = Search_Branch(Instruction
  204.                                        ,Argment,&PArea[bc],bc)) EQU 0 THEN
  205.                IF (c = Inherent_Code(Instruction,Argment
  206.                                        ,ArgmentC,&PArea[bc])) EQU 0 THEN
  207.                  IF (c = ExImmediate_Code(Instruction,Argment
  208.                                        ,ArgmentC,&PArea[bc])) EQU 0 THEN
  209.                    IF (c = InInstruction(Instruction,Argment
  210.                                        ,ArgmentC,&PArea[bc])) EQU 0 THEN
  211.                    ENDIF
  212.                  ENDIF 
  213.                ENDIF 
  214.              ENDIF
  215.            ENDIF
  216.          ENDIF
  217.        ENDIF
  218.  
  219.       Command_Line_Print(ComLine,bc,c);
  220.       bc = bc + c;
  221.     ENDIF
  222.   ENDWHILE
  223.   fclose(fp);
  224.  
  225.   fwrite(PArea,bc,1,Ofp);
  226.   fclose(Ofp);
  227.  
  228.   Dump_Code(PArea,bc);
  229.  
  230.   printf("\n*************************   Label list  ***********************");
  231.   Symbol_Print(Symbol,Symbol_Count,0);
  232. /* printf("\n*************************    EQU list   ***********************");
  233.   Symbol_Print(Equ,EQU_Count,1);
  234.   printf("\n*************************    SET list   ***********************");
  235.   Symbol_Print(Set,SET_Count,1);*/
  236.   
  237.  
  238. END
  239. /******************** 6309 asm Main routin **********************************/
  240.  
  241. /************************  Command Analysis *********************************/
  242. /*                                                                          */
  243. /*                                                                          */
  244. /*                                                                          */
  245. /*                                                                          */
  246. /*                                                                          */
  247. /*　　　テキストファイルから１行を読み込みラベル・命令・パラメータに振り    */
  248. /*    分ける。                                                              */
  249. /*                                                                          */
  250. /****************************************************************************/
  251. FUNCTION Command_Analysis(One_Line,Label,Instruction,Argment)
  252. char                     *One_Line
  253.                                ,*Label
  254.                                      ,*Instruction
  255.                                                  ,*Argment;
  256. BEGIN
  257.   int i,j,Return_Variable;
  258.  
  259.   Return_Variable = Label[0] = Instruction[0] = Argment[0] = i = j = 0;
  260.   WHILE  One_Line[i] > BLANK    AND i < 255 DO
  261.     Label[j] = toupper(One_Line[i]);
  262.     j = j + 1;
  263.     i = i + 1;
  264.   ENDWHILE
  265.   Label[i] = OFF;
  266.   WHILE (One_Line[i] EQU BLANK
  267.       OR One_Line[i] EQU TAB  ) AND i < 255 DO
  268.     i = i + 1;
  269.   ENDWHILE
  270.   j = 0;
  271.   WHILE  One_Line[i] > BLANK    AND i < 255 DO
  272.     Instruction[j] = toupper(One_Line[i]);
  273.     j = j + 1;
  274.     i = i + 1;
  275.   ENDWHILE
  276.   Instruction[j] = OFF;
  277.   WHILE  (One_Line[i] EQU BLANK
  278.       OR  One_Line[i] EQU TAB ) AND i < 255 DO
  279.     i = i + 1;
  280.   ENDWHILE
  281.   j = 0;
  282.   WHILE   One_Line[i] > BLANK   AND i < 255 DO
  283.     Argment[j] = toupper(One_Line[i]);
  284.     j = j + 1;
  285.     i = i + 1;
  286.   ENDWHILE
  287.   Argment[j] = OFF;
  288.   RETURN(Return_Variable);
  289. END
  290. /************************  Command Analysis *********************************/
  291.  
  292. /**************************  Argment Count  *********************************/
  293. /*                                                                          */
  294. /*　　”，”を一つの区切りとし、スペースを終了コードとしてパラメータの数    */
  295. /*　をカウントする。この時、”，”はヌルコードに置き換える。                */
  296. /*                                                                          */
  297. /*                                                                          */
  298. /*                                                                          */
  299. /*                                                                          */
  300. /*                                                                          */
  301. /****************************************************************************/
  302. FUNCTION  Argment_Count(Argment)
  303. char                    Argment[];
  304. BEGIN
  305.   int i,k;
  306.   i = k = 0;
  307.   IF strlen(Argment) NEQ ZERO THEN
  308.     k = 1;
  309.     WHILE Argment[i] NEQ ZERO DO
  310.       IF Argment[i] EQU COMMA THEN
  311.         Argment[i] = OFF;
  312.         k++;
  313.       ENDIF
  314.       i++;
  315.     ENDWHILE
  316.   ENDIF
  317.   RETURN(k);
  318. END
  319. /**************************  Argment Count  *********************************/
  320.  
  321. /************************ One Byte Code Analysis ****************************/
  322. /*                                                                          */
  323. /* 　本ルーチンでは１バイト命令インハレントコードのみを処理する。           */
  324. /*                                                                          */
  325. /*                                                                          */
  326. /*                                                                          */
  327. /*                                                                          */
  328. /*                                                                          */
  329. /*                                                                          */
  330. /****************************************************************************/
  331. FUNCTION One_Byte_Code(Instruction,Code)
  332. char                  *Instruction
  333.                                  ,*Code;
  334. BEGIN
  335.   static struct 
  336.     OP Oop[34] = {{ "ABX",0x3A},{"SYNC",0x13},{ "NOP",0x12},{ "MUL",0x3D}
  337.                  ,{ "SWI",0x3F},{ "DAA",0x19}
  338.                  ,{"ASLA",0x48},{"LSLA",0x48},{"ASLB",0x58},{"LSLB",0x58}
  339.                  ,{"ASRA",0x47},{"ASRB",0x57},{"CLRA",0x4F},{"CLRB",0x5F}
  340.                  ,{"COMA",0x43},{"COMB",0x53},{"DECA",0x4A},{"DECB",0x5A}
  341.                  ,{"ROLA",0x49},{"ROLB",0x59},{"RORA",0x46},{"RORB",0x56}
  342.                  ,{ "RTI",0x3B},{ "RTS",0x39},{ "SEX",0x1D},{"SEXW",0x14}
  343.                  ,{"TSTA",0x4D},{"TSTB",0x5D},{"INCA",0x4C},{"INCB",0x5C}
  344.                  ,{"LSRA",0x44},{"LSRB",0x54},{"NEGA",0x40},{"NEGB",0x50}};
  345.   int i = 0;
  346.  
  347.   WHILE strcmp(Instruction,Oop[i].op) NEQ ZERO AND i < 34 DO
  348.     i++;
  349.   ENDWHILE
  350.   IF i < 34 THEN
  351.     Code[0] = Oop[i].Code;
  352.     i = 1;
  353.   ELSE
  354.     i = 0;
  355.   ENDIF
  356.   RETURN(i);
  357.  
  358. END
  359. /************************ One Byte Code Analysis ****************************/
  360.  
  361. /************************ Two Byte Code Analysis ****************************/
  362. /*                                                                          */
  363. /*  本ルーチンでは２バイト命令インハレントコードのみを処理する。            */
  364. /*                                                                          */
  365. /*                                                                          */
  366. /*                                                                          */
  367. /*                                                                          */
  368. /*                                                                          */
  369. /*                                                                          */
  370. /****************************************************************************/
  371. FUNCTION Two_Byte_Code(Instruction,Code)
  372. char                  *Instruction
  373.                                  ,*Code;
  374. BEGIN
  375.   static struct 
  376.   OP T10op[26] = {{ "ASLD",0x48},{ "NEGD",0x40},{ "SWI2",0x3F}
  377.                  ,{ "ASLD",0x48},{ "LSLD",0x48},{ "ASRD",0x47}
  378.                  ,{ "CLRD",0x4F},{ "CLRW",0x5F},{ "COMD",0x43},{ "COMW",0x53}
  379.                  ,{ "DECD",0x4A},{ "DECW",0x5A},{ "ROLD",0x49},{ "ROLW",0x59}
  380.                  ,{ "RORD",0x46},{ "RORW",0x56},{ "TSTD",0x4D},{ "TSTW",0x5D}
  381.                  ,{ "INCD",0x4C},{ "INCW",0x5C},{ "LSRD",0x44},{ "LSRW",0x54}
  382.                  ,{"PSHSW",0x38},{"PSHUW",0x3A},{"PULSW",0x37},{"PULUW",0x3B}
  383.                    };
  384.   static struct
  385.   OP T11op[11] = {{ "SWI3",0x3F}
  386.                  ,{ "CLRE",0x4F},{ "CLRF",0x5F},{ "COME",0x43},{ "COMF",0x53}
  387.                  ,{ "DECE",0x4A},{ "DECF",0x5A},{ "TSTE",0x4D},{ "TSTF",0x5D}
  388.                  ,{ "INCE",0x4C},{ "INCF",0x5C}};
  389.  
  390.   int i = 0;
  391.  
  392.   WHILE strcmp(Instruction,T10op[i].op) NEQ ZERO AND i < 26 DO
  393.     i++;
  394.   ENDWHILE
  395.   IF i < 26 THEN
  396.     Code[0] = 0x10;
  397.     Code[1] = T10op[i].Code;
  398.     i = 2;
  399.   ELSE
  400.     i = 0;
  401.     WHILE strcmp(Instruction,T11op[i].op) NEQ ZERO AND i < 11 DO
  402.     i++;
  403.     ENDWHILE
  404.     IF i < 11 THEN
  405.       Code[0] = 0x11;
  406.       Code[1] = T11op[i].Code;
  407.       i = 2;
  408.     ENDIF
  409.     i = 0;    
  410.   ENDIF
  411.   RETURN(i);
  412. END
  413. /************************ One Byte Code Analysis ****************************/
  414.  
  415. /************************ Inherent Code Analysis ****************************/
  416. /*                                                                          */
  417. /*  インハレントコードの中でもポストバイトの処理を要するものを処理。        */
  418. /*                                                                          */
  419. /*                                                                          */
  420. /*                                                                          */
  421. /*                                                                          */
  422. /*                                                                          */
  423. /*                                                                          */
  424. /****************************************************************************/
  425. FUNCTION Inherent_Code(Instruction,Argment,ArgmentC,Code)
  426. char                  *Instruction
  427.                                  ,*Argment;
  428. int                                        ArgmentC;
  429. unsigned char                                      *Code;
  430. BEGIN
  431.   static struct
  432.     OP IOop[6]  = {{ "TFR",0x1F},{ "EXG",0x1E}
  433.                   ,{"PSHS",0x34},{"PSHU",0x36},{"PULS",0x35},{"PULU",0x37}};
  434.   static struct 
  435.     OP I10op[8] = {{"ADCR",0x31},{"ADDR",0x30},{"ANDR",0x34},{"CMPR",0x37}
  436.                   ,{"SBCR",0x33},{"SUBR",0x32},{"EORR",0x36},{ "ORR",0x35}};
  437.   int i,j,k,re;
  438.   char *TP,TEMP[2][10];
  439.   i = j = k = re = 0;
  440.   Code[0] = Code[1] = Code[2] = ZERO;
  441.   TP = Argment;
  442.  
  443.   WHILE strcmp(Instruction,IOop[i].op) NEQ ZERO AND i < 6 DO
  444.     i++;
  445.   ENDWHILE
  446.   IF i < 6 THEN
  447.     Code[0] = IOop[i].Code;
  448.     IF i EQU 0 OR i EQU 1 THEN
  449.       WHILE strcmp(TP,RNum[Code[1] / 0x10].R) NEQ ZERO DO
  450.         Code[1] = Code[1] + 0x10;
  451.       ENDWHILE
  452.       TP = TP + strlen(TP) + 1;
  453.       WHILE strcmp(TP,RNum[Code[1] & 0x0f].R) NEQ ZERO DO
  454.         Code[1]++;
  455.       ENDWHILE
  456.     ELSE
  457.       WHILE j++ < ArgmentC DO
  458.         k = 0 ;
  459.         WHILE strcmp(TP,RNum[k].R) NEQ ZERO DO
  460.           k++;
  461.         ENDWHILE
  462.         TP = TP + strlen(TP) + 1;
  463.         Code[1] = Code[1] | RNum[k].Numb;
  464.       ENDWHILE
  465.     ENDIF
  466.     re = 2;
  467.   ENDIF 
  468.   i = 0;
  469.   WHILE strcmp(Instruction,I10op[i].op) NEQ ZERO AND i < 8 DO
  470.     i++;
  471.   ENDWHILE
  472.   IF i < 8 THEN
  473.     Code[0] = 0x10;
  474.     Code[1] = I10op[i].Code;
  475.     WHILE strcmp(TP,RNum[Code[2] / 0x10].R) NEQ ZERO DO
  476.       Code[2] = Code[2] + 0x10;
  477.     ENDWHILE
  478.     TP = TP + strlen(TP) + 1;
  479.     WHILE strcmp(TP,RNum[Code[2] & 0x0f].R) NEQ ZERO DO
  480.       Code[2]++;
  481.     ENDWHILE
  482.     re = 3;
  483.   ENDIF
  484.   
  485.   IF strcmp(Instruction,"TFM") EQU ZERO THEN
  486.     strcpy(TEMP[0],TP);
  487.     TP = TP + strlen(TP) + 1;
  488.     strcpy(TEMP[1],TP);
  489.     Code[0] = 0x11;
  490.     IF   TEMP[0][strlen(TEMP[0]) - 1] EQU '-'
  491.      AND TEMP[1][strlen(TEMP[1]) - 1] EQU '-' THEN
  492.       Code[1] = 0x39;
  493.       TEMP[0][strlen(TEMP[0]) - 1] = ZERO;
  494.       TEMP[1][strlen(TEMP[1]) - 1] = ZERO;
  495.     ELSE
  496.       IF TEMP[0][strlen(TEMP[0]) - 1] EQU '+' THEN
  497.          TEMP[0][strlen(TEMP[0]) - 1] = ZERO;
  498.         IF TEMP[1][strlen(TEMP[1]) - 1] EQU '+' THEN
  499.            TEMP[1][strlen(TEMP[1]) - 1] = ZERO;
  500.           Code[1] = 0x38;
  501.         ELSE
  502.           Code[1] = 0x3A;
  503.         ENDIF
  504.       ELSE
  505.         IF TEMP[1][strlen(TEMP[1]) - 1] EQU '+' THEN
  506.            TEMP[1][strlen(TEMP[1]) - 1] = ZERO;
  507.           Code[1] = 0x3B;
  508.         ENDIF
  509.       ENDIF
  510.       re = 3;
  511.     ENDIF
  512.  
  513.     WHILE strcmp(TEMP[0],RNum[Code[2]/0x10].R) NEQ ZERO AND Code[2] < 0xFF DO
  514.       Code[2] = Code[2] + 0x10;
  515.     ENDWHILE
  516.     WHILE strcmp(TEMP[1],RNum[Code[2]&0x0F].R) NEQ ZERO AND Code[2] < 0xFF DO
  517.       Code[2]++;
  518.     ENDWHILE
  519.   ENDIF
  520.  
  521.   RETURN(re);
  522. END
  523. /************************ Inherent Code Analysis ****************************/
  524.  
  525. /************************* Branch Code Analysis *****************************/
  526. /*                                                                          */
  527. /*   ブランチ命令の処理。                                                   */
  528. /*                                                                          */
  529. /*                                                                          */
  530. /*                                                                          */
  531. /*                                                                          */
  532. /*                                                                          */
  533. /*                                                                          */
  534. /****************************************************************************/
  535. FUNCTION Search_Branch(Instruction,Argment,Code,bc)
  536. char                  *Instruction
  537.                                  ,*Argment
  538.                                          ,*Code;
  539. int                                             bc;
  540. BEGIN
  541.   int Address,i,Count;
  542.   static struct
  543.     OP Bop[21] = {{"LBSR",0x17},{"LBRA",0x16}
  544.                  ,{"BSR",0x8D},{"BRA",0x20},{"BRN",0x21}
  545.                  ,{"BHI",0x22},{"BLS",0x23},{"BCC",0x24},{"BCS",0x25}
  546.                  ,{"BHS",0x24},{"BLO",0x25},{"BNE",0x26},{"BEQ",0x27}
  547.                  ,{"BVC",0x28},{"BVS",0x29},{"BPL",0x2A},{"BMI",0x2B}
  548.                  ,{"BGE",0x2C},{"BLT",0x2D},{"BGT",0x2E},{"BLE",0x2F}};
  549.  
  550.   IF Argment[0] >= '0' AND Argment[0] <= '9' THEN
  551.     Address = atoi((char *)Argment);
  552.   ELSE
  553.     IF Argment[0] EQU '%' OR Argment[0] EQU '$' THEN
  554.       Address = BHconv(Argment[1]);
  555.     ELSE
  556.       IF Pass_flag NEQ ZERO THEN
  557.         i = 0;
  558.         WHILE strcmp(Argment,Symbol[i].SP) NEQ ZERO AND i < Symbol_Count DO
  559.          i++;
  560.         ENDWHILE
  561.         Address = (int)Symbol[i].SA;
  562.       ELSE
  563.         Address = 0x7FFF;
  564.       ENDIF
  565.     ENDIF
  566.   ENDIF
  567.  
  568.  Count = i = 0;
  569.  IF strcmp(Instruction,Bop[i++].op) EQU ZERO THEN
  570.     Count = 3;
  571.     Code[0] = Bop[0].Code;
  572.     Code[1] = (Address - bc - Count) / 0x100 & 0xFF;
  573.     Code[2] = (Address - bc - Count)         & 0xFF;
  574.   ELSEIF strcmp((char *)Instruction,Bop[i++].op) EQU ZERO THEN
  575.       Count = 3;
  576.       Code[0] = Bop[1].Code;
  577.       Code[1] = (Address - bc - Count) / 0x100 & 0xFF;
  578.       Code[2] = (Address - bc - Count)         & 0xFF;
  579.     ELSE
  580.       WHILE NOT(strcmp( Instruction   ,Bop[i].op) EQU ZERO
  581.             OR  strcmp(&Instruction[1],Bop[i].op) EQU ZERO
  582.             AND Instruction[0] EQU 'L')   AND    i < 21    DO
  583.         i++;
  584.       ENDWHILE
  585.       IF i < 20 THEN
  586.         IF Instruction[0] EQU 'L' THEN
  587.           Count = 4;
  588.           Code[0] = 0x10;
  589.           Code[1] = Bop[i].Code;
  590.           Code[2] = (Address - bc - Count) / 0x100 & 0xFF;
  591.           Code[3] = (Address - bc - Count)         & 0xFF;
  592.         ELSE
  593.           Count = 2;
  594.           Code[0] = Bop[i].Code;
  595.           Code[1] = (Address - bc - Count)         & 0xFF;
  596.         ENDIF
  597.       ENDIF
  598.     ENDIF
  599.   ENDIF
  600.   RETURN(Count);
  601. END
  602. /************************* Branch Code Analysis *****************************/
  603.  
  604. /*********************** ExImmediate Code Analysis **************************/
  605. /*   イミディエートコードのない命令全般を処理。                             */
  606. /*                                                                          */
  607. /*                                                                          */
  608. /*                                                                          */
  609. /*                                                                          */
  610. /*                                                                          */
  611. /*                                                                          */
  612. /****************************************************************************/
  613. FUNCTION ExImmediate_Code(Instruction,Argment,ArgmentC,Code)
  614. char                     *Instruction
  615.                                     ,*Argment;
  616. int                                           ArgmentC;
  617. char                                                  *Code;
  618. BEGIN
  619.   static struct 
  620.     OP EI1op[17] = {{ "NEG",0x00},{ "OIM",0x01},{ "AIM",0x02},{ "COM",0x03}
  621.                    ,{ "LSR",0x04},{ "EIM",0x05},{ "ROR",0x06},{ "ASR",0x07}
  622.                    ,{ "ASL",0x08},{ "ROL",0x09},{ "DEC",0x0A},{ "TIM",0x0B}
  623.                    ,{ "INC",0x0C},{ "TST",0x0D},{ "JMP",0x0E},{ "CLR",0x0F}
  624.                    ,{ "LSL",0x08}};
  625.   static struct
  626.     OP EI2op[31] = {{"SUBA",0x90},{"SUBB",0xD0},{"CMPA",0x91},{"CMPB",0xD1}
  627.                    ,{"SBCA",0x92},{"SBCB",0xD2},{"SUBD",0x93},{"ADDD",0xD3}
  628.                    ,{"ANDA",0x94},{"ANDB",0xD4},{"BITA",0x95},{"BITB",0xD5}
  629.                    ,{ "LDA",0x96},{ "LDB",0xD6},{ "STA",0x97},{ "STB",0xD7}
  630.                    ,{"EORA",0x98},{"EORB",0xD8},{"ADCA",0x99},{"ADCB",0xD9}
  631.                    ,{ "ORA",0x9A},{ "ORB",0xDA},{"ADDA",0x9B},{"ADDB",0xDB}
  632.                    ,{"CMPX",0x9C},{ "LDD",0xDC}              ,{ "STD",0xDD}
  633.                    ,{ "LDX",0x9E},{ "LDU",0xDE},{ "STX",0x9F},{ "STU",0xDF}};
  634.   static struct
  635.     OP E10op[18] = {{"SUBW",0x90},{"CMPW",0x91},{"SBCD",0x92},{"CMPD",0x93}
  636.                                  ,{"BITD",0x95},{ "LDW",0x96},{ "STW",0x97}
  637.                    ,{"EORD",0x98},{"ADCD",0x99},{ "ORD",0x9A},{"ADDW",0x9B}
  638.                    ,{"CMPY",0x9C}              ,{ "LDY",0x9E},{ "STY",0x9F}
  639.                    ,{ "LDQ",0xDC},{ "STQ",0xDD},{ "LDS",0xDE},{ "STS",0xDF}};
  640.   static struct
  641.     OP E11op[15] = {{"SUBE",0x90},{"CMPE",0x91}              ,{"CMPU",0x93}
  642.                                                ,{ "LDE",0x96},{ "STE",0x97}
  643.                                                              ,{"ADDE",0x9B}
  644.                    ,{"CMPS",0x9C},{"DIVD",0x9D},{"DIVQ",0x9E},{"MULD",0x9F}
  645.                    ,{"SUBF",0xD0},{"CMPF",0xD1}
  646.                                                ,{ "LDF",0xD6},{ "STF",0xD7}
  647.                                                              ,{"ADDF",0xDB}};
  648.   int re;
  649.   IF (re = NIC_Analysis(Instruction,Argment,ArgmentC
  650.                         , Code   ,Code_Info[0],EI1op,17)) EQU ZERO THEN
  651.     IF (re = NIC_Analysis(Instruction,Argment,ArgmentC
  652.                         , Code   ,Code_Info[1],EI2op,31)) EQU ZERO THEN
  653.       IF (re = NIC_Analysis(Instruction,Argment,ArgmentC
  654.                         ,&Code[1],Code_Info[1],E10op,18)) EQU ZERO THEN
  655.         IF (re = NIC_Analysis(Instruction,Argment,ArgmentC
  656.                         ,&Code[1],Code_Info[1],E11op,15)) EQU ZERO THEN
  657.         ELSE
  658.           re++;
  659.           Code[0] = 0x11;
  660.         ENDIF
  661.       ELSE
  662.         re++;
  663.         Code[0] = 0x10;
  664.       ENDIF
  665.     ENDIF
  666.   ENDIF
  667.  
  668.   RETURN(re);
  669. END
  670. /*********************** ExImmediate Code Analysis **************************/
  671.  
  672. /*********************** InImmediate Code Analysis **************************/
  673. /*                                                                          */
  674. /*   イミディエートコードを含む命令全般を処理。                             */
  675. /*                                                                          */
  676. /*                                                                          */
  677. /*                                                                          */
  678. /*                                                                          */
  679. /*                                                                          */
  680. /*                                                                          */
  681. /****************************************************************************/
  682. FUNCTION NIC_Analysis(Instruction,Argment,ArgmentC,Code,Code_Info,CP,CPc)
  683. char                  *Instruction
  684.                                  ,*Argment;
  685. int                                       ArgmentC;
  686. char                                              *Code
  687.                                                       ,*Code_Info;
  688. struct OP                                                        *CP;
  689. int                                                                  CPc;
  690. BEGIN
  691.   int i,j,re,Offset;
  692.   i = j = re = 0;
  693.   WHILE strcmp(Instruction,CP[i].op) NEQ ZERO AND i < CPc DO
  694.     i++;
  695.   ENDWHILE
  696.   IF i < CPc THEN
  697.     Code[0] = CP[i].Code;
  698.     IF ArgmentC EQU 1 THEN
  699.       switch(Argment[0])
  700.       BEGIN
  701.         case'<':
  702.           IF Argment[1] EQU '%' OR Argment[1] EQU '$' THEN
  703.             Offset = BHconv(&Argment[1]);
  704.           ELSE
  705.             Offset = atoi(&Argment[1]);
  706.           ENDIF
  707.           Code[1] = Offset;
  708.           re = 2;
  709.           break;
  710.         case'#':
  711.           IF Argment[1] EQU '%' OR Argment[1] EQU '$' THEN
  712.             Offset = BHconv(&Argment[1]);
  713.           ELSE
  714.             Offset = atoi(&Argment[1]);
  715.           ENDIF
  716.           IF Instruction[0] NEQ 'S' OR Instruction[1] NEQ 'T' THEN
  717.             Code[0] = (Code[0] & 0xCF) | Code_Info[1];
  718.             IF Instruction[strlen(Instruction) - 1] EQU 'D' THEN
  719.               Code[1] = Offset / 0x100 & 0xFF;
  720.               Code[2] = Offset         & 0xFF;
  721.               re = 3;
  722.             ELSE
  723.               Code[1] = Offset         & 0xFF;
  724.               re = 2;
  725.             ENDIF
  726.           ENDIF 
  727.           break;
  728.         case'>':
  729.           IF Argment[1] EQU '%' OR Argment[1] EQU '$' THEN
  730.             Offset = BHconv(&Argment[1]);
  731.           ELSE
  732.             Offset = atoi(&Argment[1]);
  733.           ENDIF
  734.           Code[0] = (Code[0] & 0xCF) | Code_Info[0];
  735.           Code[1] = Offset / 0x100 & 0xFF;
  736.           Code[2] = Offset         & 0xFF;
  737.           re = 3;
  738.           break;
  739.         case'[':
  740.           Code[0] = (Code[0] & 0xCF) | Code_Info[2];
  741.           Code[1] = 0xAF;
  742.           Code[2] = Offset / 0x100 & 0xFF;
  743.           Code[3] = Offset         & 0xFF;
  744.           re = 4;
  745.           break;
  746.         default:break;
  747.       END
  748.     ELSE
  749.       IF ArgmentC EQU 2 THEN
  750.         Code[0] = (Code[0] & 0xCF) | Code_Info[2];
  751.         IF (re = Direct_or_InDirect(Argment,&Code[1])) > ZERO THEN
  752.           j = 0;
  753.           re++;
  754.         ENDIF
  755.       ENDIF
  756.     ENDIF
  757.   ENDIF
  758.   RETURN(re)
  759. END
  760.  
  761. /*********************** ExImmediate Code Analysis **************************/
  762.  
  763. /************************** Direct or InDirect  *****************************/
  764. /*                                                                          */
  765. /*  ダイレクト及びインダイレクトの判定。                                    */
  766. /*                                                                          */
  767. /*                                                                          */
  768. /*                                                                          */
  769. /*                                                                          */
  770. /*                                                                          */
  771. /*                                                                          */
  772. /****************************************************************************/
  773. FUNCTION Direct_or_InDirect(Argment,Code)
  774. char                       *Argment
  775.                                   ,*Code;
  776. BEGIN
  777.   char *TEMP[2],buffer[20];
  778.   int  Return_Variable = 0;
  779.   TEMP[0] = buffer;
  780.   strcpy(TEMP[0],Argment);
  781.   TEMP[1] = TEMP[0] + strlen(TEMP[0]) + 1;
  782.   strcpy(TEMP[1],&Argment[strlen(Argment) + 1]);
  783.   IF TEMP[0][0]  EQU '[' THEN
  784.     IF TEMP[1][strlen(TEMP[1]) - 1] EQU ']' THEN
  785.       strcpy(TEMP[0],&Argment[1]);
  786.       TEMP[1][strlen(TEMP[1]) - 1] = ZERO;
  787.       IF (Return_Variable = PostByte_Analysis(TEMP,Code)) > ZERO THEN
  788.         Code[0] = Code[0] | 0x10;
  789.         IF (Code[0] & 0x8F) EQU 0x8F THEN
  790.           Code[0] = Code[0] & 0xF0;
  791.         ENDIF
  792.       ENDIF
  793.     ENDIF
  794.   ELSE
  795.     Return_Variable = PostByte_Analysis(TEMP,Code);
  796.   ENDIF
  797.   RETURN(Return_Variable);
  798. END
  799. /************************** Direct or InDirect  *****************************/
  800.  
  801. /*************************** PostByte Analysis ******************************/
  802. /*                                                                          */
  803. /*  ポストバイトの解析。                                                    */
  804. /*                                                                          */
  805. /*                                                                          */
  806. /*                                                                          */
  807. /*                                                                          */
  808. /*                                                                          */
  809. /*                                                                          */
  810. /****************************************************************************/
  811. FUNCTION PostByte_Analysis(Argment,Code)
  812. char                     **Argment
  813.                                  ,*Code;
  814. BEGIN
  815.   int Byte_Length;
  816.   IF (Byte_Length = PCW_Judgment(Argment,Code)) EQU ZERO THEN
  817.     IF (Byte_Length = AutoInc_Judgment(Argment,Code)) EQU ZERO THEN
  818.       IF (Byte_Length = Acc_Judgment(Argment,Code)) EQU ZERO THEN
  819.       ENDIF
  820.     ENDIF
  821.   ENDIF
  822.   RETURN(Byte_Length);
  823. END
  824. /*************************** PostByte Analysis ******************************/
  825.  
  826. /************************** Bit Length Judgment *****************************/
  827. /*                                                                          */
  828. /*　相対アドレスのビット長の計算。                                          */
  829. /*                                                                          */
  830. /*                                                                          */
  831. /*                                                                          */
  832. /*                                                                          */
  833. /*                                                                          */
  834. /*                                                                          */
  835. /****************************************************************************/
  836. FUNCTION BitLen(Offset)
  837. int             Offset;
  838. BEGIN
  839.   int Bit_Length = 0;
  840.   IF Offset NEQ ZERO THEN
  841.     IF Offset >= -16 AND Offset < 16 THEN
  842.       Bit_Length = 5;
  843.     ELSE
  844.       IF Offset >= -128 AND Offset < 128 THEN
  845.         Bit_Length = 8;
  846.       ELSE
  847.         IF Offset >= -32768 AND Offset < 32768 THEN
  848.           Bit_Length = 16;
  849.         ENDIF
  850.       ENDIF
  851.     ENDIF
  852.   ENDIF
  853.   RETURN(Bit_Length);
  854. END
  855. /************************** Bit Length Judgment *****************************/
  856.  
  857. /***************** PC Register And W Register Judgment **********************/
  858. /*                                                                          */
  859. /*  ＰＣレジスタとＷレジスタの判定。                                        */
  860. /*                                                                          */
  861. /*                                                                          */
  862. /*                                                                          */
  863. /*                                                                          */
  864. /*                                                                          */
  865. /*                                                                          */
  866. /****************************************************************************/
  867. FUNCTION PCW_Judgment(Argment,Code)
  868. char                **Argment
  869.                             ,*Code;
  870. BEGIN
  871.   int Bit_Length,Byte_Length,Offset,i;
  872.   IF Argment[0][0] EQU '%' OR Argment[0][0] EQU '$' THEN
  873.     Offset = BHconv(Argment[0]);
  874.   ELSE
  875.     Offset = atoi(Argment[0]);
  876.   ENDIF
  877.   IF Offset > ZERO OR strlen(Argment[0]) EQU ZERO THEN
  878.     Bit_Length = BitLen(Offset);
  879.     Byte_Length = 0;
  880.     IF strcmp(Argment[1],"PCR") EQU ZERO THEN
  881.       Code[0] = 0x8C;
  882.       IF Bit_Length > 8 THEN
  883.         Code[0] = Code[0] | 0x01;
  884.         Code[1] = Offset / 0x100 & 0xFF;
  885.         Code[2] = Offset         & 0xFF;
  886.         Byte_Length = 3;
  887.       ELSE
  888.         Code[1] = Offset         & 0xFF;
  889.         Byte_Length = 2;
  890.       ENDIF
  891.     ENDIF
  892.     IF strcmp(Argment[1],  "W") EQU ZERO THEN
  893.       Code[0] = 0x8F;
  894.       Byte_Length = 1;
  895.       IF Bit_Length NEQ ZERO THEN
  896.         Code[0] = Code[0] | 0x20;
  897.         Code[1] = Offset / 0x100 & 0xFF;
  898.         Code[2] = Offset         & 0xFF;
  899.         Byte_Length = 3;
  900.       ENDIF
  901.     ENDIF
  902.     i = 0;
  903.     WHILE strcmp(Argment[1],Post_Register[i]) NEQ ZERO AND i < 4 THEN
  904.       i++;
  905.     ENDWHILE
  906.     IF i < 4 THEN
  907.       Code[0] = (char)(i * 0x20);
  908.       Byte_Length = 1;
  909.       SWITCH(Bit_Length)
  910.         CASE( 0)
  911.           Code[0] = Code[0] | 0x84       ;BREAK
  912.         CASE( 5)
  913.           Code[0] = Code[0] | Offset     ;BREAK
  914.         CASE( 8)
  915.           Code[0] = Code[0] | 0x88       ;
  916.           Code[1] = Offset         & 0xFF;
  917.           Byte_Length++                  ;BREAK
  918.         CASE(16)
  919.           Code[0] = Code[0] | 0x89       ;
  920.           Code[1] = Offset / 0x100 & 0xFF;
  921.           Code[2] = Offset         & 0xFF;
  922.           Byte_Length = 3                ;BREAK
  923.         DEFAULT BREAK
  924.       ENDSWITCH
  925.     ENDIF
  926.   ELSE
  927.     Byte_Length = 0;
  928.   ENDIF
  929.   RETURN(Byte_Length);
  930. END
  931. /***************** PC Counter And W Register Judgment ***********************/
  932.  
  933. /*********************** Auto Incriment Judgment ****************************/
  934. /*                                                                          */
  935. /*  オートインクリメントの処理。                                            */
  936. /*                                                                          */
  937. /*                                                                          */
  938. /*                                                                          */
  939. /*                                                                          */
  940. /*                                                                          */
  941. /*                                                                          */
  942. /****************************************************************************/
  943. FUNCTION AutoInc_Judgment(Argment,Code)
  944. char                    **Argment
  945.                                 ,*Code;
  946. BEGIN
  947.   int i = 0,j = 0,Byte_Length = 0;
  948.  
  949.   IF Argment[1][strlen(Argment[1]) - 1] EQU '+' THEN
  950.     Code[0] = 0x80;
  951.     Argment[1][strlen(Argment[1]) - 1] = ZERO;
  952.     IF Argment[1][strlen(Argment[1]) - 1] EQU '+' THEN
  953.       Code[0] = Code[0] | 0x01;
  954.       Argment[1][strlen(Argment[1]) - 1] = ZERO;
  955.       IF strcmp(Argment[1],"W") EQU ZERO THEN
  956.         Byte_Length = 1;
  957.         Code[0] = 0xCF;
  958.       ENDIF
  959.     ENDIF
  960.     WHILE strcmp(Argment[1],Post_Register[i]) NEQ ZERO AND i < 4 DO
  961.       i++;
  962.     ENDWHILE
  963.     IF i < 4 THEN
  964.       Byte_Length = 1;
  965.       Code[0] = Code[0] | (char)(i * 0x20);
  966.     ENDIF
  967.   ENDIF
  968.  
  969.   IF Argment[1][0] EQU '-' THEN    
  970.     Code[0] = 0x82;
  971.     j = 1;
  972.     IF Argment[1][1] EQU '-' THEN
  973.       Code[0] = Code[0] | 0x01;
  974.       j++;
  975.       IF strcmp(&Argment[1][2],"W") EQU ZERO THEN
  976.         Byte_Length = 1;
  977.         Code[0] = 0xEF;
  978.       ENDIF      
  979.     ENDIF
  980.     WHILE strcmp(&Argment[1][j],Post_Register[i]) NEQ ZERO AND i < 4 DO
  981.       i++;
  982.     ENDWHILE
  983.     IF i < 4 THEN
  984.       Byte_Length = 1;
  985.       Code[0] = Code[0] | (char)(i * 0x20);
  986.     ENDIF
  987.   ENDIF
  988.  
  989.   RETURN(Byte_Length);
  990. END
  991. /*********************** Auto Incriment Judgment ****************************/
  992.  
  993. /************************ Accumulators Jugment ******************************/
  994. /*                                                                          */
  995. /*  アキュムレータレジスタとインデックスレジスタの演算を含んだ処理。        */
  996. /*                                                                          */
  997. /*                                                                          */
  998. /*                                                                          */
  999. /*                                                                          */
  1000. /*                                                                          */
  1001. /*                                                                          */
  1002. /****************************************************************************/
  1003. FUNCTION Acc_Judgment(Argment,Code)
  1004. char                **Argment
  1005.                             ,*Code;
  1006. BEGIN
  1007.   int i = 0;
  1008.  
  1009.   WHILE strcmp(Argment[1],Post_Register[i]) NEQ ZERO AND i < 4 DO
  1010.     i++;
  1011.   ENDWHILE
  1012.   IF i < 4 THEN
  1013.     Code[0] = (char)(i * 0x20);
  1014.     i = 1;
  1015.     IF strcmp(Argment[0],"A") EQU ZERO THEN
  1016.       Code[0] = Code[0] | 0x86;
  1017.     ELSE
  1018.       IF strcmp(Argment[0],"B") EQU ZERO THEN
  1019.         Code[0] = Code[0] | 0x85;
  1020.       ELSE
  1021.         IF strcmp(Argment[0],"D") EQU ZERO THEN
  1022.           Code[0] = Code[0] | 0x8B;
  1023.         ELSE
  1024.           IF strcmp(Argment[0],"E") EQU ZERO THEN
  1025.             Code[0] = Code[0] | 0x87;
  1026.           ELSE
  1027.             IF strcmp(Argment[0],"F") EQU ZERO THEN
  1028.               Code[0] = Code[0] | 0x8A;
  1029.             ELSE
  1030.               IF strcmp(Argment[0],"W") EQU ZERO THEN
  1031.                 Code[0] = Code[0] | 0x8E;
  1032.               ELSE
  1033.                 i = 0;
  1034.               ENDIF
  1035.             ENDIF
  1036.           ENDIF
  1037.         ENDIF
  1038.       ENDIF
  1039.     ENDIF
  1040.   ENDIF
  1041.  
  1042.   RETURN(i) 
  1043. END
  1044. /************************* Accumulators Judgment ****************************/
  1045.  
  1046. /************************** InInstruction ***********************************/
  1047. /*                                                                          */
  1048. /*  データ部表記用疑似命令処理。                                            */
  1049. /*                                                                          */
  1050. /*                                                                          */
  1051. /*                                                                          */
  1052. /*                                                                          */
  1053. /*                                                                          */
  1054. /*                                                                          */
  1055. /****************************************************************************/
  1056. FUNCTION InInstruction(Instruction,Argment,ArgmentC,Code)
  1057. char                  *Instruction
  1058.                                  ,*Argment;
  1059. int                                        ArgmentC;
  1060. char                                               *Code;
  1061. BEGIN
  1062.   int i = 0,Byte_Count = 0;
  1063.   char *TP,Delimiter;
  1064.   TP = Argment;
  1065.   IF strcmp(Instruction,"FCB") EQU ZERO THEN
  1066.     WHILE Byte_Count < ArgmentC DO
  1067.       Code[Byte_Count++] = atoi(TP);
  1068.       TP = TP + strlen(TP) + 1;
  1069.     ENDWHILE
  1070.   ELSE
  1071.     IF strcmp(Instruction,"FDB") EQU ZERO THEN
  1072.       WHILE (Byte_Count / 2) < ArgmentC DO
  1073.         Code[Byte_Count++] = atoi(TP) / 0x100 & 0xFF;
  1074.         Code[Byte_Count++] = atoi(TP)         & 0xFF;
  1075.         TP = TP + strlen(TP) + 1;
  1076.       ENDWHILE
  1077.     ELSE
  1078.       IF   strcmp(Instruction,"FCC") EQU ZERO 
  1079.         OR strcmp(Instruction,"FCS") EQU ZERO THEN
  1080.         IF Argment[0] > 0x20 AND Argment[0] <= 0x2F THEN
  1081.           Delimiter = Argment[0];
  1082.           i = 1;
  1083.           WHILE Argment[i] NEQ Delimiter DO
  1084.             Code[Byte_Count++] = Argment[i++];
  1085.           ENDWHILE
  1086.         ENDIF
  1087.         IF strcmp(Instruction,"FCS") EQU ZERO THEN
  1088.           Code[Byte_Count - 1] = Code[Byte_Count - 1] | 0x80;
  1089.         ENDIF
  1090.       ENDIF
  1091.     ENDIF
  1092.   ENDIF
  1093.   RETURN(Byte_Count);
  1094. END
  1095. /************************** InInstruction ***********************************/
  1096.  
  1097. /************************** Symbol Print ************************************/
  1098. /*                                                                          */
  1099. /*　シンボルネームの一覧。                                                  */
  1100. /*                                                                          */
  1101. /*                                                                          */
  1102. /*                                                                          */
  1103. /*                                                                          */
  1104. /*                                                                          */
  1105. /*                                                                          */
  1106. /****************************************************************************/
  1107. FUNCTION Symbol_Print(Symbol,Symbol_Count,flag)
  1108. struct SYM           *Symbol;
  1109. int                          Symbol_Count,flag;
  1110. BEGIN
  1111.   int i,j;
  1112.   i = j = 0;
  1113.   printf("\n");
  1114.   WHILE j < Symbol_Count DO
  1115.     printf("%04d %s ",j,Symbol[j].SP);
  1116.     IF flag EQU ZERO THEN
  1117.     WHILE (i + strlen(Symbol[j].SP)) < 66 DO
  1118.       printf("-");i++;
  1119.     ENDWHILE
  1120.       printf(" %04X\n",Symbol[j++].SA);
  1121.     ELSE
  1122.       WHILE (i + strlen(Symbol[j].SP) + strlen(Symbol[j - 1].SA)) < 70 DO
  1123.         printf("-");i++;
  1124.       ENDWHILE
  1125.       printf(" %s\n",Symbol[j].SA);
  1126.     ENDIF
  1127.   i = 0;
  1128.   ENDWHILE
  1129.   RETURN(0);
  1130. END
  1131. /************************** Symbol Print ************************************/
  1132.  
  1133. /*************************** Dump Code **************************************/
  1134. /*　アセンブルされたコードをダンプ形式で表示。                              */
  1135. /*                                                                          */
  1136. /*                                                                          */
  1137. /*                                                                          */
  1138. /*                                                                          */
  1139. /*                                                                          */
  1140. /*                                                                          */
  1141. /*                                                                          */
  1142. /****************************************************************************/
  1143. FUNCTION Dump_Code(Code,Count)
  1144. unsigned char     *Code;
  1145. int                     Count;
  1146. BEGIN
  1147.   int i,j;
  1148.   i = j = 0;
  1149.   printf("\n");
  1150.   WHILE i < Count DO
  1151.     printf("%04X ",i);
  1152.     j = 0;
  1153.     WHILE j++ < 16 DO
  1154.       printf("%02X ",Code[i++]);
  1155.     ENDWHILE
  1156.     printf("   ");
  1157.     j = 0;
  1158.     i = i - 16;
  1159.     WHILE j++ < 16 DO
  1160.       IF Code[i] > 0x20 THEN
  1161.         printf("%1c",Code[i]);
  1162.       ELSE
  1163.         printf(".");
  1164.       ENDIF
  1165.       i++;
  1166.     ENDWHILE
  1167.     printf("\n");
  1168.   ENDWHILE
  1169.   RETURN(0);
  1170. END
  1171. /*************************** Dump Code **************************************/
  1172.  
  1173. /*********************** Command Line Print *********************************/
  1174. /*                                                                          */
  1175. /*　コマンドラインの表示。                                                  */
  1176. /*                                                                          */
  1177. /*                                                                          */
  1178. /*                                                                          */
  1179. /*                                                                          */
  1180. /*                                                                          */
  1181. /*                                                                          */
  1182. /****************************************************************************/
  1183. FUNCTION Command_Line_Print(ComLine,bc,c)
  1184. COMLINE            ComLine;
  1185. int                        bc,c;
  1186. BEGIN
  1187.   int    j;
  1188.   char *TP;
  1189.  
  1190.   IF c NEQ ZERO THEN
  1191.     printf("%04X ",bc);
  1192.   ELSE
  1193.     printf("     ");
  1194.   ENDIF
  1195.  
  1196.   j = 0;
  1197.   WHILE j < 8 DO
  1198.     IF j++ < c THEN
  1199.       printf("%02X ",(unsigned char)PArea[bc++]);
  1200.     ELSE
  1201.       printf("   ");
  1202.     ENDIF
  1203.   ENDWHILE
  1204.  
  1205.   WHILE j++ < c DO bc++; ENDWHILE
  1206.  
  1207.   printf("%-10s",ComLine.Label);
  1208.   printf("%-6s" ,ComLine.Instruction);
  1209.   j = 0;
  1210.   TP = ComLine.Argment;
  1211.   printf("%s",TP);
  1212.   WHILE j++ < ComLine.ArgmentC - 1 DO
  1213.     TP = TP + strlen(TP) + 1;
  1214.     printf(",%s",TP);
  1215.   ENDWHILE 
  1216.   printf("\n");
  1217.   RETURN(0);
  1218. END
  1219. /*********************** Command Line Print *********************************/
  1220.  
  1221. /************************ Symbol Entry **************************************/
  1222. /*                                                                          */
  1223. /*  シンボル，ＥＱＵ，ＳＥＴ命令のラベルを登録。                            */
  1224. /*                                                                          */
  1225. /*                                                                          */
  1226. /*                                                                          */
  1227. /*                                                                          */
  1228. /*                                                                          */
  1229. /*                                                                          */
  1230. /****************************************************************************/
  1231. FUNCTION Symbol_Entry(ComLine,Symbol,Count)
  1232. COMLINE               ComLine;
  1233. SYMBOL                       *Symbol;
  1234. int                                 Count[];
  1235. BEGIN
  1236.   int i = 0;
  1237.   IF strlen(ComLine.Label) > 0 THEN
  1238.     WHILE strcmp(ComLine.Label,Symbol[i].SP) NEQ ZERO AND i++ < Count[0] DO
  1239.     ENDWHILE
  1240.     IF i < Count[0]  THEN
  1241.       IF strcmp(ComLine.Instruction,"SET") NEQ ZERO THEN
  1242.       printf("Error !!\n");
  1243.       i = -1;
  1244.       ELSE
  1245.       ENDIF
  1246.     ELSE
  1247.       strcpy(Symbol[Count[0]++].SP,ComLine.Label);
  1248.       Symbol[Count[0]].SP = Symbol[Count[0]-1].SP + strlen(ComLine.Label ) + 1;
  1249.       IF   strcmp(ComLine.Instruction,"SET") EQU ZERO
  1250.         OR strcmp(ComLine.Instruction,"EQU") EQU ZERO THEN
  1251.         strcpy(Symbol[Count[0] - 1].SA,ComLine.Argment);
  1252.         Symbol[Count[0]].SA= Symbol[Count[0]-1].SA+strlen(ComLine.Argment) + 1;
  1253.       ENDIF
  1254.     ENDIF
  1255.   ELSE
  1256.     i = -1;
  1257.   ENDIF
  1258.   RETURN(i);
  1259. END
  1260. /************************ Symbol Entry **************************************/
  1261.  
  1262. /*************************** BHconv *****************************************/
  1263. /*　アセンブルされたコードを                                                */
  1264. /*                                                                          */
  1265. /*                                                                          */
  1266. /*                                                                          */
  1267. /*                                                                          */
  1268. /*                                                                          */
  1269. /*                                                                          */
  1270. /*                                                                          */
  1271. /****************************************************************************/
  1272. FUNCTION BHconv(BH)
  1273. unsigned char   BH[];
  1274. BEGIN
  1275.   int I = 0,i = 1;
  1276.   IF BH[0] EQU '%' THEN
  1277.     WHILE BH[i] EQU 0x30 OR BH[i] EQU 0x31 DO
  1278.       I = I * 2;
  1279.       I = I + BH[i++] - '0';
  1280.     ENDWHILE
  1281.   ENDIF
  1282.   IF BH[0] EQU '$' THEN
  1283.     WHILE BH[i] >= '0' AND BH[i] <= '9' 
  1284.        OR BH[i] >= 'A' AND BH[i] <= 'F' DO
  1285.       I = I * 0x10;
  1286.       IF BH[i] > '9' THEN
  1287.         I = I + BH[i] - 'A' + 10;
  1288.       ELSE
  1289.         I = I + BH[i] - '0';
  1290.       ENDIF
  1291.       i++;
  1292.     ENDWHILE
  1293.   ENDIF
  1294.   RETURN(I);
  1295. END
  1296. /*************************** BHconv *****************************************/
  1297.